abstract class HttpTransport {
-  Future<String> get(String path, {Map<String, String>? headers});
+  Future<HttpResponse> get(String path, {Map<String, String>? headers});

-  Future<String> post(
+  Future<HttpResponse> post(
     String path, {
     Map<String, String>? headers,
     Object? body,
   });
 }
+
+class HttpResponse {
+  final int statusCode;
+  final String body;
+
+  const HttpResponse({required this.statusCode, required this.body});
+}

-    final raw = await http.get('$baseUrl/bonds', headers: _headers);
-    final payload = jsonDecode(raw) as Map<String, dynamic>;
+    final response = await http.get('$baseUrl/bonds', headers: _headers);
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw StateError('fetchBonds failed: ${response.statusCode}');
+    }
+    final payload = jsonDecode(response.body) as Map<String, dynamic>;

+  Map<String, dynamic> _decodeObject(String raw) {
+    final decoded = jsonDecode(raw);
+    if (decoded is! Map<String, dynamic>) {
+      throw const FormatException('Expected JSON object response');
+    }
+    return decoded;
+  }
+
+  List<Map<String, dynamic>> _readDataList(Map<String, dynamic> payload) {
+    final data = payload['data'];
+    if (data is! List) {
+      throw const FormatException('Expected `data` to be a list');
+    }
+    return data.map((e) {
+      if (e is! Map<String, dynamic>) {
+        throw const FormatException('Expected list items to be JSON objects');
+      }
+      return e;
+    }).toList(growable: false);
+  }
...
-    final payload = jsonDecode(raw) as Map<String, dynamic>;
-    final items = payload['data'] as List<dynamic>;
+    final payload = _decodeObject(raw);
+    final items = _readDataList(payload);
...
-    final payload = jsonDecode(raw) as Map<String, dynamic>;
-    final orderMap = (payload['data'] ?? payload) as Map<String, dynamic>;
+    final payload = _decodeObject(raw);
+    final data = payload['data'];
+    if (data is! Map<String, dynamic>) {
+      throw const FormatException('Expected `data` to be an order object');
+    }
+    final orderMap = data;
...
-    final payload = jsonDecode(raw) as Map<String, dynamic>;
-    final items = payload['data'] as List<dynamic>;
+    final payload = _decodeObject(raw);
+    final items = _readDataList(payload);

   factory BondOrderModel.fromJson(Map<String, dynamic> json) {
     return BondOrderModel(
       orderId: json['orderId'] as String,
       isin: json['isin'] as String,
       side: _decodeSide(json['side'] as String),
       type: _decodeType(json['type'] as String),
       status: _decodeStatus((json['status'] as String?) ?? 'PENDING'),
-      quantity: (json['quantity'] as num).toInt(),
-      filledQuantity: ((json['filledQuantity'] as num?) ?? 0).toInt(),
+      quantity: _asStrictInt(json['quantity'], 'quantity'),
+      filledQuantity: _asStrictInt(json['filledQuantity'] ?? 0, 'filledQuantity'),
       limitPrice: (json['limitPrice'] as num?)?.toDouble(),
       createdAt: DateTime.parse(json['createdAt'] as String),
     );
   }
+
+  static int _asStrictInt(Object? value, String field) {
+    if (value is int) return value;
+    if (value is num && value == value.roundToDouble()) return value.toInt();
+    throw ArgumentError.value(value, field, 'Expected an integer value');
+  }

   Future<BondOrder> call({
     required String isin,
     required BondOrderSide side,
     required BondOrderType type,
     required int quantity,
     double? limitPrice,
   }) {
-    if (isin.trim().isEmpty) {
+    final normalizedIsin = isin.trim();
+    if (normalizedIsin.isEmpty) {
       throw ArgumentError.value(isin, 'isin', 'ISIN is required');
     }
@@
-    if (type == BondOrderType.limit && (limitPrice == null || limitPrice <= 0)) {
+    if (type == BondOrderType.limit &&
+        (limitPrice == null || !limitPrice.isFinite || limitPrice <= 0)) {
       throw ArgumentError.value(limitPrice, 'limitPrice', 'Limit price must be provided for limit orders');
     }
 
     return _repository.placeOrder(
-      isin: isin,
+      isin: normalizedIsin,
       side: side,
       type: type,
       quantity: quantity,
       limitPrice: type == BondOrderType.market ? null : limitPrice,
     );
   }

   Future<void> _refresh() async {
     setState(() {
       _bondsFuture = widget.controller.loadBonds();
     });
-    await _bondsFuture;
+    try {
+      await _bondsFuture;
+    } catch (_) {
+      // FutureBuilder renders the error state.
+    }
   }

-class BondPreviewPage extends StatelessWidget {
+class BondPreviewPage extends StatefulWidget {
   const BondPreviewPage({super.key});
+
+  `@override`
+  State<BondPreviewPage> createState() => _BondPreviewPageState();
+}
+
+class _BondPreviewPageState extends State<BondPreviewPage> {
+  late final BondController controller;
+
+  `@override`
+  void initState() {
+    super.initState();
+    final dataSource = NseCbricsDataSource(
+      baseUrl: 'https://mock.nse-cbrics.local',
+      apiKey: 'preview-key',
+      http: MockNseCbricsTransport(),
+    );
+    final repository = BondRepositoryImpl(dataSource);
+    controller = BondController(repository);
+  }
 
   `@override`
   Widget build(BuildContext context) {
-    final dataSource = NseCbricsDataSource(
-      baseUrl: 'https://mock.nse-cbrics.local',
-      apiKey: 'preview-key',
-      http: MockNseCbricsTransport(),
-    );
-
-    final repository = BondRepositoryImpl(dataSource);
-    final controller = BondController(repository);
-
     return BondPage(controller: controller);
   }
 }

   Future<void> _submit() async {
     try {
       final qty = int.parse(_qtyController.text.trim());
       final price = double.parse(_priceController.text.trim());
       final order = await widget.controller.placeLimitBuyOrder(
         isin: widget.isin,
         quantity: qty,
         price: price,
       );
+      if (!mounted) return;
 
       setState(() {
         _message = 'Order placed: ${order.orderId}';
       });
     } catch (e) {
+      if (!mounted) return;
       setState(() {
         _message = 'Order failed: $e';
       });
     } finally {
       if (mounted) {
         setState(() => _submitting = false);
       }
     }
   }